Release 10.1A: OpenEdge Development:
Progress 4GL Reference

COMPILE statement

Compiles a procedure file or a class definition file. A compilation can last for a session, or you can save it permanently for use in later sessions (as an r-code file, which has a .r extension).

When you compile a class definition file, Progress compiles the class definition file identified in the COMPILE statement and all class files in its inherited class hierarchy, by default. You can direct Progress to compile only those class definition files in the class hierarchy that are not found in the cache, and cache any classes or interfaces it compiles during the session, by setting the MULTI-COMPILE attribute to TRUE.

Note: When you change the definition of a class, Progress Software Corporation recommends that you recompile all classes that inherit the modified class. This recommendation does not apply to method logic changes within a class.

After you compile a procedure file, you use the RUN statement to create an instance of the procedure, and you use a handle to access the procedure and its context. After you compile a class definition file, you use the NEW statement to create an object instance of the class, and you use an object reference to access the class object instance, as well as its data members and methods.

For more information about compiling procedure files, see OpenEdge Development: Progress 4GL Handbook . For more information about compiling class definition files, see OpenEdge Getting Started: Object-oriented Programming .

Syntax

COMPILE { procedure-name | type-name | VALUE ( expression ) } [ ATTR-SPACE [ = logical-expression ] ] [ SAVE [ = logical-expression ] [ INTO { directory | VALUE ( expression ) } ] ] [ LISTING { listfile | VALUE ( expression ) } [ APPEND [ = logical-expression ] | PAGE-SIZE integer-expression | PAGE-WIDTH integer-expression ] ] [ XCODE expression ] [ XREF { xreffile | VALUE ( expression ) } [ APPEND [ = logical-expression ] ] ] [ STRING-XREF { sxreffile | VALUE ( expression ) } [ APPEND [ = logical-expression ] ] ] [ STREAM-IO [ = logical-expression ] ] [ LANGUAGES ( { language-list | VALUE ( expression ) } ) [ TEXT-SEG-GROW = growth-factor ] ] [ DEBUG-LIST { debugfile | VALUE ( expression ) } ] [ PREPROCESS { preprocessfile | VALUE ( expression ) } ] [ NO-ERROR ] [ V6FRAME [ = logical-expression ] [ USE-REVVIDEO | USE-UNDERLINE ] ] [ MIN-SIZE [ = logical-expression ] ] [ GENERATE-MD5 [ = logical-expression ] ]

COMPILE { procedure-name | type-name | VALUE ( expression ) }

Specifies the name of the procedure file or class definition file you want to compile. Specify a class type name using the package.class-name syntax as described in the Type-name syntax reference entry in this book.

If you use the SAVE option, a procedure file name must have a .p extension, .w extension, or no extension; a class definition file must have a .cls extension. On UNIX, file names are case sensitive, so you must enter them exactly as they are stored.

ATTR-SPACE [ = logical-expression ]

Has no effect; supported only for backward compatibility.

XCODE expression

Decrypts the source code in procedure-name or class-name, and any encrypted include files, using the decryption key expression. Only use XCODE to decrypt files not encrypted with the default key. Include files that are not encrypted are included and compiled in the standard manner.

Having the decryption key does not allow you to examine a decrypted version of the source code.

Note: You cannot use the XCODE and LISTING or DEBUG-LIST options together. Also, you cannot use the XCODE and XREF options together. That is, you cannot create a cross-reference listing from code that is encrypted.

STREAM-IO [ = logical-expression ]

Specifies that all output from the compiled procedure or class is formatted for output to a file or printer. This means that all font specifications are ignored and all frames are treated as if they had the USE-TEXT option given. This produces a platform-independent output appropriate for printing.

If you specify a logical-expression, its value determines whether the STREAM-IO option is activated. If the logical-expression is evaluated to the Unknown value (?), a run-time error occurs.

SAVE [ = logical-expression ] [ INTO { directory | VALUE ( expression) } ]

Produces a file that contains the r-code for the procedure or class you are compiling.

When you compile a class definition file with the SAVE option, Progress produces an r-code file for the class definition file and all class files in its inherited class hierarchy. For example, if you compile a class definition file that has two classes in its inherited class hierarchy, Progress compiles three files and produces three r-code files.

These r-code files are saved across OpenEdge sessions. If you do not use the SAVE phrase, the COMPILE statement produces r-code for the source procedure or class, but the r-code is not saved across OpenEdge sessions. This r-code is a session-compile version of the procedure or class.

If you specify a logical-expression, its value determines whether the SAVE option is activated. If the logical-expression is evaluated to the Unknown value (?), a run-time error occurs.

The COMPILE SAVE statement produces r-code files with the name procedure-name.r or class-name.r, where procedure-name is the name of a procedure source file without the extension, and class-name is the name of a class source file without the extension. Progress ignores the file extension of a procedure or class definition file and always creates r-code files that use the same filename with a .r extension. For example, if you supply a filename of test, test.p, or test.cls, COMPILE SAVE produces an r-code file with the name test.r. If you specify a filename of test.bp, COMPILE SAVE still produces an r-code file with the name test.r.

Caution: Where both procedure and class definition files compile to a .r file, be sure to use distinct filenames. If you have a procedure file and a class definition file with the same name, and you compile them both with COMPILE SAVE, the first .r file will be overwritten by the second .r file.

By default, r-code files are stored in the same directory as the source procedure or class definition file. The r-code files for inherited class definition files are also stored in the same directory as their respective source files.

If you use the SAVE INTO phrase, r-code files produced by a compilation can be saved in a different directory. See the Examples and Notes sections for more information.

On UNIX and Windows, a newly created r-code file replaces any existing r-code file of the same name.

LISTING { listfile | VALUE ( expression ) }

Produces a compilation listing that includes:

The name of the file containing the procedure or class you compile.
The date and time at the start of the compilation.
The number of each line in the procedure or class file.
The block number where each statement belongs.
The complete text of all include files (except encrypted include files) and the names of any subprocedures and user-defined functions.

The listfile or VALUE ( expression ) identifies the name of the file in which you want to store the Compiler listing. If expression evaluates to the Unknown value (?), then Progress ignores the LISTING option.

APPEND [ = logical-expression ]

Appends the current listing to the contents of the listing file. If you do not use the APPEND option, Progress creates a new listing file, replacing any file of the same name.

If you specify a logical-expression, its value determines whether the APPEND option is activated. If the logical-expression is evaluated to the Unknown value (?), a run-time error occurs.

PAGE-SIZE integer-expression

Identifies the number of lines to a page in the listing file. The default page size is 55 and integer-expression must be between 10 and 127, inclusive.

PAGE-WIDTH integer-expression

Identifies the number of page columns in the listing file. The default page width is 80, and integer-expression must be between 80 and 255, inclusive. Add at least 12 spaces to the page width when you type the file. This allows you to list information that precedes each line of code, ensuring that the file appears in the listing output exactly as you typed it.

XREF { xreffile | VALUE ( expression ) } [ APPEND [ = logical-expression ] ]

Writes cross-reference information between procedures and Progress objects, or
between class or interface definition files and Progress objects, to the file xreffile or VALUE ( expression ). If expression returns the Unknown value (?), then Progress ignores the XREF option.

Note: You cannot use the XREF and XCODE options together. That is, you cannot create a cross-reference listing from code that is encrypted.

Cross-referenced objects include procedure and include files, user-defined functions, classes, methods, tables, fields, variables, frames, and character strings. XREF generates one unformatted, blank-separated line in xreffile for each referenced object. Each line has the following format:

source-name file-name line-number reference-type object-identifier

The source-name is the name of the procedure or class file you compile with the COMPILE XREF statement. The file-name is the name of the file with the referenced code. The line-number is the line number of the statement in file-name that contains the referenced object. The reference-type is the type of reference in the code (such as ACCESS or UPDATE), and the object-identifier is the Progress object being referenced.

Note: If file-name is an include file, source-name is the file that includes the include file.

The possible reference types and object identifiers appear in Table 15.

Table 15: Reference types and object identifiers

Reference type	Object identifier
ACCESS	{ [database.]table field [WORKTABLE] } | { SHARED variable} | { PUBLIC-DATA-MEMBER class-name:data-member-name} | { INHERITED-DATA-MEMBER class-name:data-member-name}
CLASS	class-name,[INHERITS inherited-class-name [(inherited-class-name ...)]], [IMPLEMENTS interface-name [interface-name]...], [USE-WIDGET-POOL],[FINAL]
COMPILE	procedure | class-file
CONSTRUCTOR	{ PUBLIC | PROTECTED} ,,,constructor-name,void, [parameter1 [,parameter2]...]
CPINTERNAL	name-of-the-code-page-that-Progress-uses-in-memory
CPSTREAM	name-of-the-code-page-that-Progress-uses-for-stream-I/O
CREATE	[database.]table [ WORKTABLE]
DATA-MEMBER	{ PUBLIC | PROTECTED | PRIVATE } data-member-name
DELETE	[database.]table [WORKTABLE]
DESTRUCTOR	PUBLIC,,,destructor-name,void,
DLL-ENTRY	procedure-name,,[parameter1 [,parameter2]...]
EXTERN	function-name,return-type,[parameter1 [,parameter2]...]
FUNCTION	function-name,return-type,[parameter1 [,parameter2]...]
GLOBAL-VARIABLE	global-variable
INCLUDE	include-file-name
INTERFACE	interface-name,,,,
INVOKE	class-name:method-name ([parameter-type[,parameter-type]... ])
METHOD	{ PUBLIC | PROTECTED | PRIVATE }, [OVERRIDE],[FINAL],method-name, return-type,[parameter1[,parameter2]...]
NEW-SHR-FRAME	new-shared-frame
NEW-SHR-VARIABLE	new-shared-variable
NEW-SHR-WORKTABLE	new-shared-worktable [LIKE [database.]table]
PROCEDURE	procedure-name,,[parameter1 [,parameter2]...]
PUBLISH	event-name|(exp)
REFERENCE	{[database.]table field [WORKTABLE]} | {SHARED variable}
RUN	procedure-name | value(exp)
SEARCH	[database.]table {index | RECID | WORKTABLE | TEMPTABLE} [WHOLE-INDEX]1
SHR-FRAME	shared-frame
SHR-WORKTABLE	shared-worktable [LIKE [database.]table]
SORT-ACCESS	{[database.]table field [WORKTABLE | TEMPTABLE]}
SORT-BY-EXP	{ FOR EACH | OPEN QUERY } table BY expression
STRING	char-string max-length justification translatable [FORMAT]
SUBSCRIBE	event-name|(exp)
UNSUBSCRIBE	event-name|(exp)|ALL
UPDATE	{[database.]table field [WORKTABLE]} | {SHARED variable} | {PUBLIC-DATA-MEMBER class-name:data-member-name} | {INHERITED-DATA-MEMBER class-name:data-member-name}
WHOLE-INDEX means that the selection criteria specified to search the table does not offer opportunities to use indexes that allow optimized key references (bracketed high and low values). Instead, Progress must search the entire table using available indexes (often only the primary index) to satisfy the query, hence a WHOLE-INDEX search. Thus, depending on the query, you might be able to optimize the search by adding indexes. See also Notes.

If you specify the APPEND option, the cross-reference information is appended to an existing file. The first line of cross-reference information for a procedure contains the object identifier for the COMPILE reference type. This allows you to easily find where the information for each compilation begins. If you specify a logical-expression, its value determines whether the APPEND option is activated. If the logical-expression is evaluated to the Unknown value (?), a run-time error occurs.

STRING-XREF { sxreffile | VALUE ( expression ) }
[ APPEND [ = logical-expression ] ]

Writes cross-reference string information between procedures and Progress objects,
or between class definition files and Progress objects, to the file sxreffile or VALUE ( expression ). If expression evaluates to the Unknown value (?), Progress ignores the STRING-XREF option.

String Xref Version x.y source-file code-page

The x.y is a major.minor version number, where a major version change implies a formatting change that will not be backward compatible with older versions of TranManII. The source-file is the name of the file from which the strings are extracted. The code-page is the code page with which the file was written.

The line for each string appears in the following format:

line-number object-name string max-length string-justification statement-type detail-info

The line-number is the same as line-number in the standard XREF file. The object-name is the name of the object with which the string is associated. The max-length and string-justification come from the string attribute (either explicit or implicit) and reflect the attributes applied to the string as it is entered into the text segment.

The statement-type describes the type of statement in which the string appears. Only one statement type appears in a given string’s output line. The following values are possible:

Statement type values
ASSIGN	DEF-SUB-MENU	INSERT	PUT-SCREEN
CASE	DISPLAY	MESSAGE	REPEAT
CREATE	DO	OPEN-QUERY	RUN
DEF-BROWSE	ENABLE	OTHER	SET
DEF-BUTTON	EXPORT	PAUSE	STATUS
DEF-FRAME	FOR	PROMPT-FOR	UPDATE
DEF-IMAGE	FORM	PUT	VIEW-AS
DEF-MENU	IF

Note: Any statement type that is not included in the preceding list will appear as OTHER.

The detail-info is one or more detail tags that specify more specifically where the string appears in the statement. The following values are possible:

Detail tags
ASSIGN	FORMAT	MESSAGE	TITLE
COL-LABEL	IMAGE-FILE	NON-ALPHA	VALUE
COMBO-BOX-ITEM	INPUT	PROMSGS	WHEN
CUR-LANG	INPUT-PARAM	PROPATH	WHERE
DEFAULT	LABEL	SEL-LIST-ITEM	WHILE
EXPR	LIST-ITEM	TERMCAP

Note: The NON-ALPHA tag indicates that a string consists entirely of blanks or digits.
The FORMAT tag is followed by one of the following tags: CHAR, NUMERIC (includes decimal and integer), DATE, or BOOL. These tags indicate the type of format. When a string can appear in only one place in a statement, no detail tag appears.

Table 16 shows the valid combinations of statement types and detail tags.

Table 16: Valid statement type and detail tag combination

Statement type	Detail tags
ASSIGN	CUR-LANG, PROMSGS, PROPATH, TERMCAP
CASE	WHEN
CREATE	N/A
DEF-BROWSE	FORMAT, COL-LABEL
DE-FBUTTON	IMAGE-FILE, LABEL
DEF-FRAME	FORMAT, COL-LABEL, LABEL
DEF-IMAGE	IMAGE-FILE
DEF-MENU	TITLE, LABEL
DEF-SUB-MENU	LABEL
DISPLAY	FORMAT, LABEL, COL-LABEL, WHEN, TITLE
DO	WHILE, WHERE, TITLE
ENABLE	LABEL, COL-LABEL, WHEN, TITLE
EXPORT	FORMAT
FOR	WHILE, WHERE, TITLE
FORM	FORMAT
IF	N/A
INSERT	TITLE
MESSAGE	TITLE, FORMAT
PAUSE	MESSAGE
PROMPT-FOR	WHEN, TITLE, FORMAT, LABEL, COL-LABEL
PUT	N/A
PUT-SCREEN	N/A
REPEAT	WHILE, TITLE, WHERE
RUN	INPUT-PARAM
SET	WHEN, ASSIGN, FORMAT, LABEL, COL-LABEL, TITLE
STATUS	DEFAULT, INPUT
UPDATE	WHEN, ASSIGN, FORMAT, LABEL, COL-LABEL, TITLE
VIEW-AS	SEL-LIST-ITEM, COMBO-BOX-ITEM

LANGUAGES ( { language-list | VALUE ( expression ) } )

Identifies which language segments to include in the compiled r-code. The language-list is a colon-separated list of language names used to generate each text segment. If you specify VALUE ( expression ), the expression must evaluate to a comma-separated list of language names. If expression evaluates to the Unknown value (?), then Progress ignores the LANGUAGES option.

Translated character strings for each specified language are read from the translation database and are stored in segments within the r-code.

COMPILE myfile.p LANGUAGES(French-Canadian:French:English, Portuguese:Spanish, New-York:American:English).

If you use an expression to specify language-list, you must use the VALUE option.

COMPILE myfile.p LANGUAGES (VALUE(char-var)). /* char-var = "French-Canadian:French:English, Portuguese:Spanish, New-York:American:English" */

In this example, the compiler searches the translation database for French-Canadian translations. If a French-Canadian translation is not found, the compiler searches for a French translation. If a French translation is not found, the compiler searches for an English translation. If an English translation is not found, the compiler uses the strings from the source code.

This example generates four text segments: French-Canadian, Portuguese, New-York, and the unnamed (default) text segment. The first language name in each language-list argument designates the name of the text segment and specifies the first language that the compiler looks up in the translation database. As a result, it is possible to create a text segment whose name has no relationship to the languages it is composed of. For example, the following argument creates a text segment named BABEL:

LANGUAGES(BABEL:French:Spanish:Italian:German)

Provided there is no language named BABEL in the translation database, the strings in this text segment would be either French, Spanish, Italian, or German, depending on which strings have translations in which languages.

TEXT-SEG-GROW = growth-factor

Specifies the factor by which Progress increases the length of strings. When you develop an application that is going to be translated, it is important to allow for the growth of the text in your widgets. If you use the TEXT-SEG-GROW option, Progress increases the size of the text strings when it compiles your application.

Progress uses the following formula to determine the length of strings:

New-length = Actual-length * [ 1 + (growth-factor/100 * (table-value/100)) ]

Where:

New-length is the new string length.
Actual-length is the actual string length.
growth-factor is the value specified with the TEXT-SEG-GROW option.
table-value is the appropriate percentage from the following table:

String length	Expansion percentage
1–10 characters	200%
11–20 characters	100%
21–30 characters	80%
31–50 characters	60%
51–70 characters	40%
More than 70 characters	30%

For example, if you have a text string that is 25 characters and you specify a growth-factor of 50, Progress applies the formula as follows and defines the New-length as 35:

New-length = 25 * [ 1 + (80/100 * (50/100)) ]

Note: TEXT-SEG-GROW is supported only when you also use the LANGUAGES option.

DEBUG-LIST { debugfile | VALUE ( expression ) }

Writes the debug listing to the file debugfile or VALUE ( expression ). If expression evaluates to the Unknown value (?), then Progress ignores the DEBUG-LIST option. The debugfile consists of a line-numbered listing of the procedure with the text of all preprocessor include files, names, and parameters inserted.

PREPROCESS { preprocessfile | VALUE ( expression ) }

Preprocesses the procedure or class definition file and writes the preprocessed source code to the file preprocessfile or VALUE ( expression ). If expression evaluates to the Unknown value (?), Progress ignores the PREPROCESS option. The preprocessfile is a text file that contains a final version of your source code after all include files have been inserted and all text substitutions have been performed.

NO-ERROR

Specifies that any errors that occur as a result of the compilation are suppressed. After the COMPILE statement completes, you can check the ERROR and WARNING attributes of the COMPILER system handle to determine whether an error has occurred or any warning messages were produced. You then can check the ERROR-STATUS handle for the specific messages.

V6FRAME [ = logical-expression ] [USE-REVVIDEO | USE-UNDERLINE]

The V6FRAME option is designed specifically to compile and run Progress Version 6 applications with Progress Version 7 or later in Windows. This option uses the V6FontNumber setting in the [Startup] section of the current environment (which might be the Registry or an initialization file) to calculate the height and width of a character unit and then set the layout grid used to compile frames for display in Progress Version 7 or later.

At run time, the FONT attribute for a frame compiled with the V6FRAME option is set to the font number specified with the V6FontNumber setting. The default setting for the V6FontNumber setting is 3.

By default, V6FRAME displays a border around a fill-in field. This means that your code requires more space on the screen than in Progress Version 6. You can override this behavior with one of the following options:

USE-REVVIDEO displays no border around a fill-in field. When a fill-in is enabled for input, the color of the fill-in changes to the color specified with the INPUT setting in the [Colors] section in the current environment (which might be the registry or an initialization file). The IBEAM cursor signals that a fill-in field has input focus.
USE-UNDERLINE displays no border around a fill-in widget. When a fill-in is enabled for input, the underline attribute of the font (V6FontNumber) for the fill-in is turned on. The color of a fill-in enabled for input does not change. The IBEAM cursor signals that a fill-in field has input focus.

The V6FRAME option also limits the vertical size of a frame title to one character unit based upon the layout grid. The text of the frame title is in the font specified with the V6FontNumber setting in the [Startup] section of the current environment (which might be the registry or an initialization file).

The V6FRAME option governs the appearance of screen output only. Use the STREAM-IO option to compile procedures that output to files and printers. If you specify the V6FRAME and STREAM-IO options in the same COMPILE statement, the STREAM-IO option overrides the V6FRAME option.

If you specify a logical-expression, its value determines whether the V6 compile option is activated. If the logical-expression is evaluated to the Unknown value (?), a run-time error occurs.

For more information on the environment for an OpenEdge session, see OpenEdge Deployment: Managing 4GL Applications .

MIN-SIZE [ = logical-expression ]

Minimizes the size of the generated r-code file by eliminating the Debugger Segment (which is used by the OpenEdge Debugger) and the signature descriptor data (which is used by the Open Client Proxy Generator).

If you specify a logical-expression, its value determines whether the MIN-SIZE option is activated (TRUE) or not (FALSE). If the logical-expression evaluates to the Unknown value (?), a run-time error occurs. The default value is FALSE.

GENERATE-MD5 [ = logical-expression ]

When Progress compiles a procedure or class definition file with the GENERATE-MD5 option, it generates a special MD5 value based on the code content, and stores it in the r-code file. This r-code MD5 value is similar to a CRC value, except the MD5 value is 128 bits in size and the CRC value is only 16 bits. The MD5 value is virtually guaranteed to be different if the file content has changed. As with CRC, content changes include any schema changes. That is, if only the schema changes, the MD5 value also changes.

If you specify a logical-expression, its value determines whether the GENERATE-MD5 option is activated (TRUE) or not (FALSE). The default value is TRUE.

You can read the MD5-VALUE attribute on the RCODE-INFO system handle to determine the MD5 value for a procedure or class.

This option is supported for WebClient™ only (that is, only WebClient uses the resulting MD5 value). Progress recommends compiling your WebClient application procedures with this option. Using this option lets WebClient determine if an r-code file has changed since the previous version of the application.

Examples

In this procedure, Progress creates an r-code version of the ord-ent procedure, naming it ord-ent.r:

r-cmple.p

COMPILE ord-ent SAVE.

Note: The sample procedures supplied with Progress do not include the ord-ent procedure.

In this procedure, Progress compiles the demo1 procedure, reserving spaces in frame layouts for special field attributes and producing an r-code file, demo1.r, that can be used across OpenEdge sessions. Progress saves the r-code file in the current directory.

r-cmple2.p

COMPILE demo1 ATTR-SPACE SAVE.

You can save the r-code file in a different directory by using the SAVE INTO phrase. For example, to save an r-code file in /usr/sources on a UNIX system, enter this command:

COMPILE demo1 ATTR-SPACE SAVE INTO /usr/sources.

The following example shows the effect of include files on compilation listings:

r-incl.p

FOR EACH customer: {r-fcust.i} {r-dcust.i} END.

Suppose you use the following COMPILE statement to compile the r-incl.p procedure:

r-comlis.p

COMPILE r-incl.p SAVE LISTING r-incl.lis XREF r-incl.xrf DEBUG-LIST r-incl.dbg.

This COMPILE statement produces four files: r-incl.r, r-incl.lis, r-incl.xrf, and r-incl.dbg.

The following procedures contain the contents of the r-incl.lis, r-incl.xrf, and r-incl.dbg files:

r-incl.lis

r-incl.p 06/01/93 13:06:30 PROGRESS(R) Page 1 {} Line Blk -- ---- --- 1 /* r-incl.p */ 2 3 1 FOR EACH customer: 4 1 {r-fcust.i} 1 1 1 /* r-fcust.i */ 1 2 1 1 3 1 FORM customer.cust-num customer.name LABEL "Customer Name" 1 4 1 customer.phone FORMAT "999-999-9999". 4 1 5 1 {r-dcust.i} 1 1 1 /* r-dcust.i */ 1 2 1 1 3 1 DISPLAY customer.cust-num customer.name customer.phone. 5 1 6 END. ^Lr-incl.p 06/01/93 13:06:30 PROGRESS(R) Page 2 File Name Line Blk. Type Tran Blk. Label -------------------- ---- --------- ---- -------------------------------- r-incl.p 0 Procedure No r-incl.p 3 For No Buffers: sports.Customer Frames: Unnamed ^L

This sample output is not an exact copy of the r-incl.lis file.

There are three columns next to the procedure in the listing file:

{} — The level of the include file.
Line — The line number in the file.
Blk — The number of the block.

The information follows each of the procedure blocks or function blocks:

Line — The line number where the block starts.
Blk. Type — The type of block (Procedure, DO, FOR EACH, REPEAT).
Tran — Whether the block is a transaction block.
Blk. Label — The label of the block.
Buffers — The name of the record buffer scoped to the block.
Frames — The name of the frame scoped to the block.

This is the cross-reference file r-incl.xrf:

r-incl.xrf

r-incl.p r-incl.p 1 COMPILE r-incl.p r-incl.p r-incl.p 3 STRING "Customer" 8 NONE UNTRANSLATABLE r-incl.p r-incl.p 3 SEARCH sports.Customer Cust-Num r-incl.p r-incl.p 4 INCLUDE r-fcust.i r-incl.p r-fcust.i 3 ACCESS sports.Customer Cust-Num r-incl.p r-fcust.i 3 ACCESS sports.Customer Name r-incl.p r-fcust.i 3 ACCESS sports.Customer Phone r-incl.p r-fcust.i 3 STRING ">>>>9" 5 NONE TRANSLATABLE FORMAT r-incl.p r-fcust.i 3 STRING "x(20)" 5 NONE TRANSLATABLE FORMAT r-incl.p r-fcust.i 3 STRING "999-999-9999" 12 NONE TRANSLATABLE FORMAT r-incl.p r-incl.p 5 INCLUDE r-dcust.i r-incl.p r-dcust.i 3 ACCESS sports.Customer Cust-Num r-incl.p r-dcust.i 3 ACCESS sports.Customer Name r-incl.p r-dcust.i 3 ACCESS sports.Customer Phone r-incl.p r-incl.p 6 STRING "Cust-Num" 8 LEFT TRANSLATABLE r-incl.p r-incl.p 6 STRING "Customer Name" 13 LEFT TRANSLATABLE r-incl.p r-incl.p 6 STRING "Phone" 5 LEFT TRANSLATABLE r-incl.p r-incl.p 6 STRING "-------- ---------------------- --------------" 46 LEFT TRANSLATABLE r-incl.p r-incl.p 6 STRING "Cust-Num" 8 LEFT TRANSLATABLE

Each line in the xref file specifies the procedure, line number, access type, and access information. The first line in the xref file contains the COMPILE access type directive and the name of the procedure exactly as it appears in the COMPILE statement. See Table 15 for a list of the values that follow a particular access type (for example, table and index after SEARCH).

This is the debug listing r-incl.dbg:

r-incl.dbg

1 /* r-incl.p */ 2 3 FOR EACH customer: 4 5 /* r-fcust.i */ 6 7 FORM customer.cust-num customer.name LABEL "Customer 8 Name" customer.phone FORMAT "999-999-9999". 9 10 11 /* r-dcust.i */ 12 13 DISPLAY customer.cust-num customer.name customer.phone 14 15 END.

Notes

When compiling class definition files, the following options apply to the class definition file identified in the COMPILE statement and all class files in its inherited class hierarchy: XCODE, STREAM-IO, LANGUAGES, V6FRAME, MIN-SIZE and GERNERATE-MD5.
When compiling class definition files, the following options apply only to the class definition file identified in the COMPILE statement, and not to the class files in its inherited class hierarchy: PREPROCESS, LISTING, DEBUG-LIST, XREF, and STRING-XREF.
If you want all record retrieval statements in a procedure to default to NO-LOCK, you must compile the procedure in an OpenEdge session started with the No Lock (-NL) startup parameter. For more information on record locking, see OpenEdge Development: Progress 4GL Handbook . For more information on the No Lock (-NL) startup parameter, see OpenEdge Deployment: Startup Command and Parameter Reference .
The value of the PROPATH environment variable defines the list of directories (path) to use when searching for a procedure.
On UNIX, you define the PROPATH variable in a startup script or in your .profile file. In Windows, you can define your PROPATH in the Registry or in an initialization file. You can also define the PROPATH interactively at the operating system level.

In addition to any directories you define for PROPATH, Progress searches the directory containing the Progress system software. If you do not define a value for PROPATH, Progress searches your working directory by default.

To locate the source file that you name in the COMPILE SAVE statement, Progress searches the first directory in PROPATH. If the source file is there, Progress compiles the source file and creates an r-code file. On UNIX, this new r-code file replaces any existing r-code file. If errors occur during compilation, Progress does not produce an r-code file and leaves existing r-code files unchanged.

If Progress cannot find the source file, it continues on to the next directory in PROPATH.

Use the SAVE INTO phrase to store a compiled r-code file in a different directory from its corresponding source file.

If you specify a relative pathname for the source file, that pathname is appended to the SAVE INTO path. For example (using UNIX pathnames):

PROPATH="/pro1/source". COMPILE test/proc1.p SAVE INTO /pro1/obj.

In the example, Progress saves the source file /pro1/source/test/proc1.p as /pro1/obj/test/proc1.r.

If the source file is a full pathname, Progress stores the r-code file in the SAVE INTO directory; it drops its original directory path.

COMPILE /pro1/obj/test/proc1.p SAVE INTO /usr/rcode.

In the example, Progress saves the source file as /usr/rcode/proc1.r.

When you use the SAVE INTO phrase to store compiled r-code files for one or more class definition files specified with a package, Progress creates a directory structure under the specified SAVE INTO directory that is consistent with the directory structure of the original source files relative to PROPATH (if the directory structure doesn’t already exist). That is, Progress creates a subdirectory under the specified SAVE INTO directory to match the original source directory for each class definition file in the hierarchy.

For example, if the source for two class definition files in a class hierarchy reside in two different directories, such as dir1 and dir2, Progress creates two matching subdirectories named dir1 and dir2 under the specified SAVE INTO directory and stores the r-code files in their respective subdirectories.

If the SAVE INTO pathname is null, Progress saves r-code files in the same directory as their source files.

The ATTR-SPACE/NO-ATTR-SPACE designation in a Frame phrase takes precedence over an ATTR-SPACE/NO-ATTR-SPACE designation in a Format phrase. The ATTR-SPACE/NO-ATTR-SPACE designation in a Format phrase takes precedence over an ATTR-SPACE/NO-ATTR-SPACE designation in a COMPILE statement.
To locate a file with the COMPILE statement (without the SAVE phrase), Progress searches the first directory in PROPATH for a usable r-code file. A usable r-code file must meet these criteria:
It must have the correct format; it must have been produced by the COMPILE SAVE statement.
It must have been produced by the current version of the Progress Compiler.
It must have the same cyclic redundancy check (CRC) value as any database tables it references, or the same time stamp if you are running with the Timestamp (-tstamp) parameter. When creating an r-code file, Progress includes, as part of the r-code file, either the CRC or the time stamp of the most recent change to the database schema that affects this procedure (for example, adding or deleting a field or index definition in a table that the procedure references).
On UNIX, it must have read access to the r-code file.

If there is a usable r-code file, there is no reason to perform the compilation. You receive an error and the compilation stops unless you have specified the XREF, LISTING, PREPROCESS, or DEBUG-LIST option. If you specified one of these options, Progress continues with the compilation and produces the files specified and a session compile. If Progress does create a session compile version, the version is not used when you use the RUN statement. The RUN statement always uses an existing r-code file before using a session compile version of a procedure.

If there is no usable r-code file, Progress searches the same directory in PROPATH for a source file. If the source file is there, Progress compiles it into the session compile file. If it is not there, Progress continues on to the next directory in PROPATH, searching for an r-code file, then for a source file.

After you compile a procedure, the RUN statement does not recompile it. If you RUN a procedure multiple times within a session, changing the procedure between runs, you must manually recompile the procedure each time. Otherwise, the procedure’s last r-code, which persists for a session, is found and the procedure is not automatically recompiled.
The size of the r-code might vary, depending on the window system on which it is compiled.
Modifications to existing field definitions do not affect database table CRC or time-stamp values. Therefore, updating a table’s existing field definitions does not invalidate r-code versions of procedures that reference the table. However, adding or deleting tables, fields, or indexes does affect database table CRC and time stamps. This invalidates r-code versions of procedures that reference the changed tables.
When you use a reserved keyword to specify a language with the LANGUAGES option, you must use quotation marks (" ") around the language-list.
The SORT-BY-EXP reference in the XREF is used to indicate a FOR EACH or OPEN QUERY statement which contains a BY clause which uses an expression.
A WHOLE-INDEX search reported for a table occurs when an entire index is used to search the table. (That is, the bracket used by the query to search the table spans the entire index.) This can occur either when no selection criteria are specified to limit the range of index keys searched (that is, to bracket a subset of the index) or when there is no appropriate index available to optimize the selection criteria. For example, the following queries on Customer table of the sports database both result in WHOLE-INDEX searches. The first query uses the Name index to search the entire table, returning every record in Name order. The second query uses the primary index to search the entire table because there is no index provided for the Balance field to limit the search.

FOR EACH Customer USE-INDEX Name: DISPLAY Customer. END. FOR EACH Customer WHERE Balance < 10000 AND Balance > 5000: DISPLAY Customer. END.

On the other hand, the following queries do not result in WHOLE-INDEX searches because the selection criteria directly limit the range of Name and Cust-Num index keys (respectively) to be searched:

FOR EACH Customer WHERE Name < "Penan Sporttiklubi" AND Name > "Chip’s Poker": DISPLAY Customer. END. FOR EACH Customer WHERE Cust-Num < 40: DISPLAY Customer. END.

For SpeedScript, the following options are invalid: V6FRAME, USE-REVVIDEO, and USE-UNDERLINE.

See also

COMPILER system handle, NEW statement, RUN statement, No Lock (-NL) Startup Parameter (in OpenEdge Deployment: Startup Command and Parameter Reference )